/**
 * 任务控制器
 * 处理任务相关的业务逻辑
 */
const taskModel = require('../models/taskModel');
const logger = require('../utils/logger');

const taskController = {
  /**
   * 获取任务列表
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件函数
   */
  getTasks: async (req, res, next) => {
    try {
      const userId = req.user.id;
      
      // 提取查询参数
      const filters = {
        status: req.query.status !== undefined ? parseInt(req.query.status) : undefined,
        category_id: req.query.category_id,
        date: req.query.date
      };

      const tasks = await taskModel.findAll(userId, filters);
      
      res.json({
        data: tasks,
        count: tasks.length
      });
    } catch (error) {
      logger.error(`获取任务列表错误: ${error.message}`);
      next(error);
    }
  },

  /**
   * 获取单个任务
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件函数
   */
  getTask: async (req, res, next) => {
    try {
      const taskId = req.params.id;
      const userId = req.user.id;

      const task = await taskModel.findById(taskId, userId);
      
      if (!task) {
        return res.status(404).json({ message: '任务不存在' });
      }

      res.json({ data: task });
    } catch (error) {
      logger.error(`获取任务详情错误: ${error.message}`);
      next(error);
    }
  },

  /**
   * 创建任务
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件函数
   */
  createTask: async (req, res, next) => {
    try {
      const userId = req.user.id;
      const taskData = {
        ...req.body,
        user_id: userId
      };

      const newTask = await taskModel.create(taskData);
      
      res.status(201).json({
        message: '任务创建成功',
        data: newTask
      });
    } catch (error) {
      logger.error(`创建任务错误: ${error.message}`);
      next(error);
    }
  },

  /**
   * 更新任务
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件函数
   */
  updateTask: async (req, res, next) => {
    try {
      const taskId = req.params.id;
      const userId = req.user.id;
      const updateData = req.body;

      // 检查任务是否存在
      const existingTask = await taskModel.findById(taskId, userId);
      if (!existingTask) {
        return res.status(404).json({ message: '任务不存在' });
      }

      const success = await taskModel.update(taskId, userId, updateData);
      
      if (!success) {
        return res.status(400).json({ message: '更新失败' });
      }

      // 获取更新后的任务
      const updatedTask = await taskModel.findById(taskId, userId);

      res.json({
        message: '任务已更新',
        data: updatedTask
      });
    } catch (error) {
      logger.error(`更新任务错误: ${error.message}`);
      next(error);
    }
  },

  /**
   * 删除任务
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件函数
   */
  deleteTask: async (req, res, next) => {
    try {
      const taskId = req.params.id;
      const userId = req.user.id;

      // 检查任务是否存在
      const existingTask = await taskModel.findById(taskId, userId);
      if (!existingTask) {
        return res.status(404).json({ message: '任务不存在' });
      }

      const success = await taskModel.delete(taskId, userId);
      
      if (!success) {
        return res.status(400).json({ message: '删除失败' });
      }

      res.json({
        message: '任务已删除',
        id: taskId
      });
    } catch (error) {
      logger.error(`删除任务错误: ${error.message}`);
      next(error);
    }
  },

  /**
   * 获取任务分类
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件函数
   */
  getCategories: async (req, res, next) => {
    try {
      const userId = req.user.id;
      const categories = await taskModel.getCategories(userId);
      
      res.json({
        data: categories,
        count: categories.length
      });
    } catch (error) {
      logger.error(`获取分类错误: ${error.message}`);
      next(error);
    }
  },

  /**
   * 创建任务分类
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 下一个中间件函数
   */
  createCategory: async (req, res, next) => {
    try {
      const userId = req.user.id;
      const categoryData = {
        ...req.body,
        user_id: userId
      };

      const newCategory = await taskModel.createCategory(categoryData);
      
      res.status(201).json({
        message: '分类创建成功',
        data: newCategory
      });
    } catch (error) {
      logger.error(`创建分类错误: ${error.message}`);
      next(error);
    }
  }
};

module.exports = taskController; 